package com.sa.ibiz.demo.demo.domain;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonProperty.Access;
import lombok.Data;
import org.springframework.beans.BeanUtils;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.cglib.beans.BeanGenerator;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.FieldFill;
import java.util.Map;
import java.util.HashMap;
import org.springframework.util.StringUtils;
import com.sa.ibiz.demo.ibizutil.security.AuthenticationUser;
import java.util.Date;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
import org.springframework.util.DigestUtils;
import org.springframework.util.StringUtils;
import java.util.UUID;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import org.springframework.cglib.beans.BeanCopier;
import com.sa.ibiz.demo.ibizutil.annotation.Dict;
import com.sa.ibiz.demo.ibizutil.domain.EntityBase;
import java.io.Serializable;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import java.math.BigInteger;
import com.sa.ibiz.demo.ibizutil.enums.FillMode;
import com.sa.ibiz.demo.ibizutil.enums.PredefinedType;
import com.sa.ibiz.demo.ibizutil.annotation.PreField;
import com.alibaba.fastjson.annotation.JSONField;


/**
 * 实体[Services] 数据对象
 */
@TableName(value = "T_SRFSERVICE",resultMap = "ServicesResultMap")
@JsonIgnoreProperties(ignoreUnknown = true)
@Data
public class Services extends EntityBase implements Serializable{

    @Dict(dictName = "WorkflowMob_ServiceContainerCodeList")
    private String container;
    @PreField(fill= FillMode.INSERT,preType = PredefinedType.CREATEDATE)
    private Timestamp createdate;
    @PreField(fill= FillMode.INSERT,preType = PredefinedType.CREATEMAN)
    @Dict(dictName = "WorkflowMob_SysOperatorCodeList")
    private String createman;
    private String errorinfo;
    private String memo;
    private String reserver;
    private Integer runorder;
    @TableId(value= "serviceid",type=IdType.UUID)//指定主键生成策略
    private String serviceid;
    private String servicename;
    private String serviceobject;
    private String serviceparam;
    @Dict(dictName = "WorkflowMob_ServiceRunStateCodeList")
    private String servicestate;
    @Dict(dictName = "WorkflowMob_ServiceStartModeCodeList")
    private String startmode;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.UPDATEDATE)
    private Timestamp updatedate;
    @PreField(fill= FillMode.INSERT_UPDATE,preType = PredefinedType.UPDATEMAN)
    @Dict(dictName = "WorkflowMob_SysOperatorCodeList")
    private String updateman;
    /**
     *  设置属性值[服务容器]
     *  @param container
     */
    public void setContainer(String container){
        if(StringUtils.isEmpty(container))
            container=null;
        this.container = container;
        this.set("containerdirtyflag",true);
    }
    /**
     *  获取属性值[服务容器]
     */
    public String getContainer(){
        return this.container;
    }
    /**
     *  重置属性值[服务容器]
     */
    public void resetContainer(){
        this.set("containerdirtyflag",false);
        this.container = null;
    }
    /**
     *  设置属性值[建立时间]
     *  @param createdate
     */
    public void setCreatedate(Timestamp createdate){
        this.createdate = createdate;
        this.set("createdatedirtyflag",true);
    }
    /**
     *  获取属性值[建立时间]
     */
    public Timestamp getCreatedate(){
        return this.createdate;
    }
    /**
     *  重置属性值[建立时间]
     */
    public void resetCreatedate(){
        this.set("createdatedirtyflag",false);
        this.createdate = null;
    }
    /**
     *  设置属性值[建立人]
     *  @param createman
     */
    public void setCreateman(String createman){
        if(StringUtils.isEmpty(createman))
            createman=null;
        this.createman = createman;
        this.set("createmandirtyflag",true);
    }
    /**
     *  获取属性值[建立人]
     */
    public String getCreateman(){
        return this.createman;
    }
    /**
     *  重置属性值[建立人]
     */
    public void resetCreateman(){
        this.set("createmandirtyflag",false);
        this.createman = null;
    }
    /**
     *  设置属性值[错误信息]
     *  @param errorinfo
     */
    public void setErrorinfo(String errorinfo){
        if(StringUtils.isEmpty(errorinfo))
            errorinfo=null;
        this.errorinfo = errorinfo;
        this.set("errorinfodirtyflag",true);
    }
    /**
     *  获取属性值[错误信息]
     */
    public String getErrorinfo(){
        return this.errorinfo;
    }
    /**
     *  重置属性值[错误信息]
     */
    public void resetErrorinfo(){
        this.set("errorinfodirtyflag",false);
        this.errorinfo = null;
    }
    /**
     *  设置属性值[备注]
     *  @param memo
     */
    public void setMemo(String memo){
        if(StringUtils.isEmpty(memo))
            memo=null;
        this.memo = memo;
        this.set("memodirtyflag",true);
    }
    /**
     *  获取属性值[备注]
     */
    public String getMemo(){
        return this.memo;
    }
    /**
     *  重置属性值[备注]
     */
    public void resetMemo(){
        this.set("memodirtyflag",false);
        this.memo = null;
    }
    /**
     *  设置属性值[保留字段]
     *  @param reserver
     */
    public void setReserver(String reserver){
        if(StringUtils.isEmpty(reserver))
            reserver=null;
        this.reserver = reserver;
        this.set("reserverdirtyflag",true);
    }
    /**
     *  获取属性值[保留字段]
     */
    public String getReserver(){
        return this.reserver;
    }
    /**
     *  重置属性值[保留字段]
     */
    public void resetReserver(){
        this.set("reserverdirtyflag",false);
        this.reserver = null;
    }
    /**
     *  设置属性值[服务次序]
     *  @param runorder
     */
    public void setRunorder(Integer runorder){
        this.runorder = runorder;
        this.set("runorderdirtyflag",true);
    }
    /**
     *  获取属性值[服务次序]
     */
    public Integer getRunorder(){
        return this.runorder;
    }
    /**
     *  重置属性值[服务次序]
     */
    public void resetRunorder(){
        this.set("runorderdirtyflag",false);
        this.runorder = null;
    }
    /**
     *  设置属性值[服务标识]
     *  @param serviceid
     */
    public void setServiceid(String serviceid){
        if(StringUtils.isEmpty(serviceid))
            serviceid=null;
        this.serviceid = serviceid;
        this.set("serviceiddirtyflag",true);
    }
    /**
     *  获取属性值[服务标识]
     */
    public String getServiceid(){
        return this.serviceid;
    }
    /**
     *  重置属性值[服务标识]
     */
    public void resetServiceid(){
        this.set("serviceiddirtyflag",false);
        this.serviceid = null;
    }
    /**
     *  设置属性值[服务名称]
     *  @param servicename
     */
    public void setServicename(String servicename){
        if(StringUtils.isEmpty(servicename))
            servicename=null;
        this.servicename = servicename;
        this.set("servicenamedirtyflag",true);
    }
    /**
     *  获取属性值[服务名称]
     */
    public String getServicename(){
        return this.servicename;
    }
    /**
     *  重置属性值[服务名称]
     */
    public void resetServicename(){
        this.set("servicenamedirtyflag",false);
        this.servicename = null;
    }
    /**
     *  设置属性值[服务对象]
     *  @param serviceobject
     */
    public void setServiceobject(String serviceobject){
        if(StringUtils.isEmpty(serviceobject))
            serviceobject=null;
        this.serviceobject = serviceobject;
        this.set("serviceobjectdirtyflag",true);
    }
    /**
     *  获取属性值[服务对象]
     */
    public String getServiceobject(){
        return this.serviceobject;
    }
    /**
     *  重置属性值[服务对象]
     */
    public void resetServiceobject(){
        this.set("serviceobjectdirtyflag",false);
        this.serviceobject = null;
    }
    /**
     *  设置属性值[服务参数]
     *  @param serviceparam
     */
    public void setServiceparam(String serviceparam){
        if(StringUtils.isEmpty(serviceparam))
            serviceparam=null;
        this.serviceparam = serviceparam;
        this.set("serviceparamdirtyflag",true);
    }
    /**
     *  获取属性值[服务参数]
     */
    public String getServiceparam(){
        return this.serviceparam;
    }
    /**
     *  重置属性值[服务参数]
     */
    public void resetServiceparam(){
        this.set("serviceparamdirtyflag",false);
        this.serviceparam = null;
    }
    /**
     *  设置属性值[服务运行状态]
     *  @param servicestate
     */
    public void setServicestate(String servicestate){
        if(StringUtils.isEmpty(servicestate))
            servicestate=null;
        this.servicestate = servicestate;
        this.set("servicestatedirtyflag",true);
    }
    /**
     *  获取属性值[服务运行状态]
     */
    public String getServicestate(){
        return this.servicestate;
    }
    /**
     *  重置属性值[服务运行状态]
     */
    public void resetServicestate(){
        this.set("servicestatedirtyflag",false);
        this.servicestate = null;
    }
    /**
     *  设置属性值[启动模式]
     *  @param startmode
     */
    public void setStartmode(String startmode){
        if(StringUtils.isEmpty(startmode))
            startmode=null;
        this.startmode = startmode;
        this.set("startmodedirtyflag",true);
    }
    /**
     *  获取属性值[启动模式]
     */
    public String getStartmode(){
        return this.startmode;
    }
    /**
     *  重置属性值[启动模式]
     */
    public void resetStartmode(){
        this.set("startmodedirtyflag",false);
        this.startmode = null;
    }
    /**
     *  设置属性值[更新时间]
     *  @param updatedate
     */
    public void setUpdatedate(Timestamp updatedate){
        this.updatedate = updatedate;
        this.set("updatedatedirtyflag",true);
    }
    /**
     *  获取属性值[更新时间]
     */
    public Timestamp getUpdatedate(){
        return this.updatedate;
    }
    /**
     *  重置属性值[更新时间]
     */
    public void resetUpdatedate(){
        this.set("updatedatedirtyflag",false);
        this.updatedate = null;
    }
    /**
     *  设置属性值[更新人]
     *  @param updateman
     */
    public void setUpdateman(String updateman){
        if(StringUtils.isEmpty(updateman))
            updateman=null;
        this.updateman = updateman;
        this.set("updatemandirtyflag",true);
    }
    /**
     *  获取属性值[更新人]
     */
    public String getUpdateman(){
        return this.updateman;
    }
    /**
     *  重置属性值[更新人]
     */
    public void resetUpdateman(){
        this.set("updatemandirtyflag",false);
        this.updateman = null;
    }
    /**
     * 重置当前数据对象属性值
     */
    public  void reset(){
        resetContainer();
        resetCreatedate();
        resetCreateman();
        resetErrorinfo();
        resetMemo();
        resetReserver();
        resetRunorder();
        resetServiceid();
        resetServicename();
        resetServiceobject();
        resetServiceparam();
        resetServicestate();
        resetStartmode();
        resetUpdatedate();
        resetUpdateman();
    }
     /**
     * 获取数据主键（普通主键与联合主键）
     * @return
     */
    @JsonIgnore
    public Serializable getDefaultPrimaryKey()
    {
	    //随机生成主键
         return  IdWorker.get32UUID();

    }
     /**
     * 复制当前对象数据到目标对象(粘贴重置)
     *
     * @throws Exception
     */
    public Services copyTo(Services targetEntity)
	{
		BeanCopier copier=BeanCopier.create(Services.class, Services.class, false);
		copier.copy(this, targetEntity, null);
        targetEntity.resetServiceid();
		return targetEntity;
	}
}